/**
 * 与树处理相关的函数
 * @date     2019-01-03
 * @author   尹学江
 */
import _ from 'lodash'

// 数组根据函数进行排序
function sortData(data, sortFun) {
  data.sort(sortFun)
}
/**
 * 生成排序函数
 * @param {String}  sortField  排序字段
 * @param { Boolean} asc       是否正序
 * @returns {Function}  排序函数
 */
function generateSortFn(sortField, asc) {
  return function(a, b) {
    const valueA = a[sortField]
    const valueB = b[sortField]
    if (valueA > valueB) {
      if (asc) {
        return 1
      } else {
        return -1
      }
    } else if (asc) {
      return -1
    } else {
      return 1
    }
  }
}

/**
 * 数组结构转化成树结构
 * @returns {Array}
 */
export const arrayToTree = function(
  data = [],
  invalidIds = [],
  id = 'id',
  pid = 'parent_id'
) {
  // 结果
  const result = []
  // 复制数据
  const dataTemp = _.cloneDeep(data)

  dataTemp.forEach(item => {
    // 添加children
    // if (!item.children) {
    //   item['children'] = []
    // }
    // 去掉无效节点
    if (invalidIds.indexOf(item[id]) > -1) return

    // pid值
    const pidValue = item[pid]

    // 不存在parent值
    if (!pidValue) {
      result.push(item)
    } else {
      // 父对象
      const parent = _.find(dataTemp, node => {
        return node[id] === pidValue
      })
      // 不存在父对象
      if (!parent) {
        result.push(item)
        return
      } else if (!parent.children) {
        parent.children = []
      }
      // 添加到父对象children
      parent.children.push(item)
    }
  })
  return result
}

/**
 * 对树进行排序(通过自定义函数)
 * @param {Array}  treeData  树
 * @param {Function}  sortFun  排序函数
 * @returns {Array}
 */
export const sortTreeByFunction = function(treeData, sortFun) {
  sortData(treeData, sortFun)
  treeData.forEach(item => {
    const children = item.children
    if (children && children.length > 0) {
      sortData(children, sortFun)
      sortTreeByFunction(children, sortFun)
    }
  })
  return treeData
}

/**
 * 对树进行排序(通过字段)
 * @param {Array}  treeData  树
 * @param {String}  sortField  排序字段
 * @param { Boolean} asc       是否正序
 * @returns {Array} 排序树
 */
export const sortTreeByField = function(treeData, sortField, asc = true) {
  return sortTreeByFunction(treeData, generateSortFn(sortField, asc))
}

/**
 * 树转化数组
 * @param {Array}  treeData  树
 * @returns {Array} 数组
 */
export const treeToArray = function(treeData) {
  let result = []
  Array.from(treeData).forEach(record => {
    result.push(record)
    if (record.children && record.children.length > 0) {
      const children = treeToArray(record.children)
      result = result.concat(children)
    }
  })
  return result
}
